.TITLE	BFCTL
	.IDENT	/01.10/
 
;
; Copyright (c) 1995-1999 by Mentec, Inc., U.S.A.
; All rights reserved
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
; OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
; VERSION 07
;
; D. N. CUTLER 26-DEC-73
;
; PREVIOUSLY MODIFIED BY:
;
;	D. N. CUTLER
;	T. J. MILLER
;
; MODIFIED BY:
;
;	T. J. MILLER 9-MAY-77
;
;		TM082 -- SAVE AND RESTORE R5 IN $BLXIO.
;
;	T. J. MILLER 14-AUG-77
;
;		TM099 -- REMOVE UNEEDED CONDITIONALIZATION FOR RSX-11M+.
;
;	J. E. PROVINO 24-JUN-79
;
;		JP131 -- CHANGE CONDITIONALS FOR NEW REAL TIME DEVICES.
;
;	D. CARROLL	28-JUL-1994		;08
;
;		DC296 -- INCLUDE SUPPORT FOR BLOCK MOVE INSTRUCTION WITHIN
;			 ROUTINE $BLXIO
;
;	D. CARROLL	19-April-1995		;09
;
;		DC357 -- DON'T MAKE BLOCK MOVE A RUN-TIME TEST, HANDLE IT
;			 WITHIN SAVE
;
; Modified for RSX-11M-PLUS V4.6 by:
;
;	D. Carroll	18-Oct-1995		01.10
;		DC404 - Include PSECT definition to allow ICB pool to be
;			fully expanded when able ...
;
;
; BUFFER CONTROL ROUTINES
;
; MACRO LIBRARY CALLS
;

	.MCALL	HWDDF$
	HWDDF$			;DEFINE HARDWARE REGISTERS

	.IIF	DF,K$$DAS&I$$CBP,	.PSECT	EXEC1				;DC404
;+
; **-$GTBYT-GET NEXT BYTE FROM USER BUFFER
;
; THIS ROUTINE IS CALLED TO GET THE NEXT BYTE FROM THE USER BUFFER
; AND RETURN IT TO THE CALLER ON THE STACK. AFTER THE BYTE HAS BEEN
; FETCHED, THE NEXT BYTE ADDRESS IS INCREMENTED.
;
; INPUTS:
;
;	R5=ADDRESS OF THE UCB THAT CONTAINS THE BUFFER POINTERS.
;
; OUTPUTS:
;
;	THE NEXT BYTE IS FETCHED FROM THE USER BUFFER AND RETURNED
;	TO THE CALLER ON THE STACK. THE NEXT BYTE ADDRESS IS INCREMENTED.
;
;	ALL REGISTERS ARE PRESERVED ACROSS CALL.
;-

	.ENABL	LSB
$GTBYT::MOV	(SP),-(SP)	;DUPLICATE RETURN ADDRESS
	MOV	KISAR6,-(SP)	;SAVE CURRENT MAPPING
	MOV	U.BUF(R5),KISAR6 ;MAP TO USER BUFFER
	MOVB	@U.BUF+2(R5),4(SP) ;GET NEXT BYTE FROM USER BUFFER
	MOV	(SP)+,KISAR6	;RESTORE CURRENT MAPPING
	BR	20$		;TAKE COMMON EXIT FOR ADDRESS UPDATE

;+
; **-$PTBYT-PUT NEXT BYTE IN USER BUFFER
;
; THIS ROUTINE IS CALLED TO PUT A BYTE IN THE NEXT LOCATION IN
; USER BUFFER. AFTER THE BYTE HAS BEEN STORED, THE NEXT BYTE ADDRESS
; IS INCREMENTED.
;
; INPUTS:
;
;	R5=ADDRESS OF THE UCB THAT CONTAINS THE BUFFER POINTERS.
;	2(SP)=BYTE TO BE STORED IN THE NEXT LOCATION OF THE USER BUFFER.
;
; OUTPUTS:
;
;	THE BYTE IS STORED IN THE USER BUFFER AND REMOVED FROM
;	THE STACK. THE NEXT BYTE ADDRESS IS INCREMENTED.
;
;	ALL REGISTERS ARE PRESERVED ACROSS CALL.
;-

$PTBYT::MOV	KISAR6,-(SP)	;SAVE CURRENT MAPPING
	MOV	U.BUF(R5),KISAR6 ;MAP TO USER BUFFER
	MOVB	4(SP),@U.BUF+2(R5) ;STORE BYTE IN USER BUFFER
	MOV	(SP)+,KISAR6	;RESTORE CURRENT MAPPING
	MOV	(SP)+,(SP)	;COLLAPSE STACK REMOVING BYTE
	BR	20$		;TAKE COMMON EXIT FOR ADDRESS UPDATE

;+
; **-$GTWRD-GET NEXT WORD FROM USER BUFFER
;
; THIS ROUTINE IS CALLED TO GET THE NEXT WORD FROM THE USER BUFFER
; AND RETURN IT TO THE CALLER ON THE STACK. AFTER THE WORD HAS BEEN
; FETCHED, THE NEXT WORD ADDRESS IS CALCULATED.
;
; INPUTS:
;
;	R5=ADDRESS OF THE UCB THAT CONTAINS THE BUFFER POINTERS.
;
; OUTPUTS:
;
;	THE NEXT WORD IS FETCHED FROM THE USER BUFFER AND RETURNED
;	TO THE CALLER ON THE STACK. THE NEXT WORD ADDRESS IS CALCULATED.
;
;	ALL REGISTERS ARE PRESERVED ACROSS CALL.
;-

$GTWRD::MOV	(SP),-(SP)	;DUPLICATE RETURN ADDRESS
	MOV	KISAR6,-(SP)	;SAVE CURRENT MAPPING
	MOV	U.BUF(R5),KISAR6 ;MAP TO USER BUFFER
	MOV	@U.BUF+2(R5),4(SP) ;GET NEXT WORD FROM USER BUFFER
	MOV	(SP)+,KISAR6	;RESTORE CURRENT MAPPING
	BR	10$		;TAKE COMMON EXIT FOR ADDRESS UPDATE

;+
; **-$PTWRD-PUT NEXT WORD IN USER BUFFER
;
; THIS ROUTINE IS CALED TO PUT A WORD IN THE NEXT LOCATION IN
; USER BUFFER. AFTER THE WORD HAS BEEN STORED, THE NEXT WORD ADDRESS
; IS CALCULATED.
;
; INPUTS:
;
;	R5=ADDRESS OF THE UCB THAT CONTAINS THE BUFFER POINTERS.
;	2(SP)=WORD TO BE STORED IN THE NEXT LOCATION OF THE BUFFER.
;
; OUTPUTS:
;
;	THE WORD IS STORED IN THE USER BUFFER AND REMOVED FROM
;	THE STACK. THE NEXT WORD ADDRESS IS CALCULATED.
;
;	ALL REGISTERS ARE PRESERVED ACROSS CALL.
;-

$PTWRD::MOV	KISAR6,-(SP)	;SAVE CURRENT MAPPING
	MOV	U.BUF(R5),KISAR6 ;MAP TO USER BUFFER
	MOV	4(SP),@U.BUF+2(R5);STORE WORD IN USER BUFFER
	MOV	(SP)+,KISAR6	;RESTORE CURRENT MAPPING
	MOV	(SP)+,(SP)	;COLLAPSE STACK REMOVING WORD
10$:	INC	U.BUF+2(R5)	;CALCULATE ADDRESS OF NEXT WORD
20$:	INC	U.BUF+2(R5)	;INCREMENT NEXT BYTE ADDRESS
	CMP	U.BUF+2(R5),#160000 ;OVERFLOW 28K BOUNDARY?
	BLO	30$		;IF LO NO
	SUB	#20000,U.BUF+2(R5) ;REDUCE BY 4K
	ADD	#200,U.BUF(R5)	;ADJUST RELOCATION BIAS
30$:	RETURN
	.DSABL	LSB

;+
; **-$GTCWD-GET NEXT WORD FROM USER CONTROL BUFFER
;
; THIS ROUTINE IS CALLED TO GET THE NEXT WORD FROM THE USER CONTROL
; BUFFER AND RETURN IT TO THE CALLER ON THE STACK. AFTER THE WORD HAS
; BEEN FETCHED, THE NEXT WORD ADDRESS IS CALCULATED.
;
; INPUTS:
;
;	R5=ADDRESS OF THE UCB THAT CONTAINS THE BUFFER POINTERS.
;
; OUTPUTS:
;
;	THE NEXT WORD IS FETCHED FROM THE USER CONTROL BUFFER AND RETURNED
;	TO THE CALLER ON THE STACK. THE NEXT WORD ADDRESS IS CALCULATED.
;
;	ALL REGISTERS ARE PRESERVED ACROSS CALL.
;-


	.IF DF	A$$D01!A$$F11!I$$CAD!U$$ADM!I$$PAD!I$$P14

$GTCWD::MOV	(SP),-(SP)	;DUPLICATE RETURN ADDRESS
	MOV	KISAR6,-(SP)	;SAVE CURRENT MAPPING
	MOV	U.CBF(R5),KISAR6 ;MAP TO USER CONTROL BUFFER
	MOV	@U.CBF+2(R5),4(SP) ;GET NEXT WORD FROM USER BUFFER
	MOV	(SP)+,KISAR6	;RESTORE CURRENT MAPPING
	ADD	#2,U.CBF+2(R5)	;CALCULATE ADDRESS OF NEXT WORD
	BIT	#20000,U.CBF+2(R5) ;OVERFLOW 4K BOUNDRY?
	BEQ	10$		;IF EQ NO
	BIC	#20000,U.CBF+2(R5) ;CLEAR OVERFLOW BIT
	ADD	#200,U.CBF(R5)	;ADJUST RELOCATION BIAS
10$:	RETURN			;

	.ENDC


;+
; **-$BLXIO-MOVE BLOCK OF DATA.
;
; THIS ROUTINE IS CALLED TO MOVE DATA IN MEMORY IN A MAPPED SYSTEM.
;
; INPUTS:
;
;	R0=NUMBER OF BYTES TO MOVE.
;	R1=SOURCE APR5 BIAS.
;	R2=SOURCE DISPLACEMENT.
;	R3=DESTINATION APR6 BIAS.
;	R4=DESTINATION DISPLACEMENT.
;
; OUTPUTS:
;
;	DESCRIBED MOVE IS ACCOMPLISHED.
;	R0 ALTERED
;	R1,R3 PRESERVED
;	R2,R4 POINT TO LAST BYTE OF SOURCE AND DESTINATION + 1
;
;	NOTE:	THE COUNT INPUT IN R0 MUST NOT BE ZERO AND IT MUST NOT
;		BE LARGE ENOUGH TO CROSS APR BOUNDARIES (THIS TYPICALLY
;		MEANS A MAXIMUM OF 4K-63).
;-

$BLXIO::MOV	R5,-(SP)	;SAVE R5
	MOV	#KISAR6,R5	;POINT TO KERNAL APR6
	MOV	(R5),-(SP)	;SAVE KERNAL APR6
	MOV	R3,(R5)		;SET UP KERNAL APR6 FOR TRANSFER
	MOV	-(R5),-(SP)	;SAVE KERNAL APR5
	MOV	R1,(R5)		;SET UP KERNAL APR5 FOR TRANSFER


	.IF NDF	N$$MOV

10$:	MOVB	(R2)+,(R4)+	;MOVE NEXT BYTE
	DEC	R0		;MORE TO MOVE?
	BNE	10$		;IF NE YES

S$$BLX	== 0
S$$BRB	== 0

	.IFF

S$$BLX	==.

	MOVR$	R2,R4,R0	; MOVE ALL DATA
	BR	90$		; ALL DONE

.	= S$$BLX		; **WARNING** THE NEXT INSTRUCTION MAY BE
;				; OVERWRITTEN WITH THE PREVIOUS INSTRUCTION
;				; SEQUENCE.
	MOV	#1,-(SP)	;PUSH LOW BIT MASK

	BIT	(SP),R2		;SOURCE ADDRESS ODD?
	BEQ	10$		;IF EQ NO
	MOVB	(R2)+,(R4)+	;MOVE FIRST BYTE
	DEC	R0		;REDUCE COUNT
10$:	BIT	(SP),R4		;DESTINATION ADDRESS ODD?
	BNE	50$		;IF NE YES, PERFORM BYTE MOVES
20$:	SUB	#N$$MOV*2,R0	;MOVE ENTIRE BLOCK?
	BCC	40$		;IF CC YES
	BIC	R0,(SP)		;REMAINING COUNT ODD?
	BNE	30$		;IF NE NO
	DEC	R0		;ADJUST NEGATIVE COUNT
30$:	SUB	R0,PC		;INDEX INTO MOVE INSTRUCTIONS
40$:				;REF LABEL


	.REPT	N$$MOV

	MOV	(R2)+,(R4)+	;MOVE A WORD

	.ENDR


	BCC	20$		;IF CC MORE TO GO
	BR	80$		;EXIT THROUGH COMMON CODE
50$:	ASL	R0		;DOUBLE COUNT
60$:	SUB	#N$$MOV*2,R0	;MOVE ENTIRE BLOCK?
	BCC	70$		;IF CC YES
	SUB	R0,PC		;ELSE INDEX INTO MOVE INSTRUCTIONS
70$:				;REF LABEL


	.REPT	N$$MOV

	MOVB	(R2)+,(R4)+	;MOVE A BYTE

	.ENDR


	BCC	60$		;IF CC MORE TO GO
80$:	TST	(SP)+		;POP CONSTANT
	BNE	90$		;IF NE NO MORE TO MOVE
	MOVB	(R2)+,(R4)+	;MOVE LAST BYTE
90$:				;REF LABEL

S$$BRB	==<BR+<<90$-S$$BLX+4>/2>>

	.ENDC


	MOV	(SP)+,(R5)+	;RESTORE KERNAL APR5
	MOV	(SP)+,(R5)	;RESTORE KERNAL APR6
	MOV	(SP)+,R5	;RESTORE R5
	RETURN			;

	.END